/**
 *--------------------------------------------------------------------\n
 *          HSLU T&A Hochschule Luzern Technik+Architektur            \n
 *--------------------------------------------------------------------\n
 * 
 * \brief         Bibliothek der Fonts
 * \file      	  GFont.c
 * \author        Colucci Domenico, domenico.colucci@stud.hslu.ch
 * \date          29.11.2012
 * 
 *     Settings    :
 *
 *     Contents    :
 *
 *		   GetFontChar           - PGFONT_CharInfo GFONT1_GetFontChar(byte ch);
**         GetBoxHeight          - byte GFONT1_GetBoxHeight(void);
**         GetFont               - PGFONT_Callbacks GFONT1_GetFont(void);
**         GetUnderlineBoxHeight - byte GFONT1_GetUnderlineBoxHeight(void);
**         GetLineSpaceHeight    - byte GFONT1_GetLineSpaceHeight(void);
 * 
 * \b Language:   Ansi-C \n\n
 * \b Target:     Medusa-Trainer \n 
 *
 *--------------------------------------------------------------------
 */

#include "GFONT.h"

/*
Copyright 1988 Bitstream, Inc., Cambridge, Massachusetts, USA
Bitstream and Charter are registered trademarks of Bitstream, Inc.
The names "Bitstream" and "Charter" are registered trademarks of
Bitstream, Inc. Permission to use these trademarks is hereby
granted only in association with the images described in this file.
Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Bitstream not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission. Bitstream makes no representations about the
suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
BITSTREAM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
NO EVENT SHALL BITSTREAM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*******************************************************************
Copyright 1984-1989, 1994 Adobe Systems Incorporated.
Copyright 1988, 1994 Digital Equipment Corporation.
Adobe is a trademark of Adobe Systems Incorporated which may be
registered in certain jurisdictions.
Permission to use these trademarks is hereby granted only in
association with the images described in this file.
Permission to use, copy, modify, distribute and sell this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notices appear in all
copies and that both those copyright notices and this permission
notice appear in supporting documentation, and that the names of
Adobe Systems and Digital Equipment Corporation not be used in
advertising or publicity pertaining to distribution of the software
without specific, written prior permission. Adobe Systems and
Digital Equipment Corporation make no representations about the
suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
*******************************************************************

(c) Copyright 1989 Sun Microsystems, Inc. Sun design patents
pending in the U.S. and foreign countries. OPEN LOOK is a
trademark of AT&T. Used by written permission of the owners.
(c) Copyright Bigelow & Holmes 1986, 1985. Lucida is a registered
trademark of Bigelow & Holmes. Permission to use the Lucida
trademark is hereby granted only in association with the images
and fonts described in this file.
SUN MICROSYSTEMS, INC., AT&T, AND BIGELOW & HOLMES
MAKE NO REPRESENTATIONS ABOUT THE SUITABILITY OF
THIS SOURCE CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS"
WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
SUN MICROSYSTEMS, INC., AT&T AND BIGELOW & HOLMES,
SEVERALLY AND INDIVIDUALLY, DISCLAIM ALL WARRANTIES
WITH REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE. IN NO EVENT SHALL SUN MICROSYSTEMS,
INC., AT&T OR BIGELOW & HOLMES BE LIABLE FOR ANY
SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
WITH THE USE OR PERFORMANCE OF THIS SOURCE CODE.
*******************************************************************
Copyright (c) 1987, 1994 Digital Equipment Corporation
The name "Bitstream" is a registered trademark of Bitstream, Inc.
Permission to use this trademark is hereby granted only in association
with the images described in this file.
The X Consortium, and any party obtaining a copy of these files from
the X Consortium, directly or indirectly, is granted, free of charge, a
full and unrestricted irrevocable, world-wide, paid up, royalty-free,
nonexclusive right and license to deal in this software and
documentation files (the "Software"), including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons who receive
copies from any such party to do so. This license includes without
limitation a license to do the foregoing actions under any patents of
the party supplying this software to the X Consortium.
Digital Equipment Corporation make no representations about the
suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
*/



#ifndef NULL
  #define NULL ((void*)0)
#endif

const byte GFONT1_FBBy = 12;

static const byte helvR08L1_0x00_BMP[] = {
  0xA8,
  0x00,
  0x88,
  0x00,
  0x88,
  0x00,
  0xA8
};

static const byte helvR08L1_0x20_BMP[] = {
  0x00
};

static const byte helvR08L1_0x21_BMP[] = {
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x00,
  0x80
};

static const byte helvR08L1_0x22_BMP[] = {
  0xA0,
  0xA0
};

static const byte helvR08L1_0x23_BMP[] = {
  0x28,
  0x28,
  0x7C,
  0x28,
  0xF8,
  0x50,
  0x50
};

static const byte helvR08L1_0x24_BMP[] = {
  0x20,
  0x70,
  0xA8,
  0xA0,
  0x70,
  0x28,
  0x28,
  0xA8,
  0x70,
  0x20
};

static const byte helvR08L1_0x25_BMP[] = {
  0x64,
  0x94,
  0x68,
  0x08,
  0x10,
  0x16,
  0x29,
  0x26
};

static const byte helvR08L1_0x26_BMP[] = {
  0x60,
  0x90,
  0x90,
  0x60,
  0x94,
  0x88,
  0x98,
  0x64
};

static const byte helvR08L1_0x27_BMP[] = {
  0x80,
  0x80
};

static const byte helvR08L1_0x28_BMP[] = {
  0x20,
  0x40,
  0x40,
  0x80,
  0x80,
  0x80,
  0x80,
  0x40,
  0x40,
  0x20
};

static const byte helvR08L1_0x29_BMP[] = {
  0x80,
  0x40,
  0x40,
  0x20,
  0x20,
  0x20,
  0x20,
  0x40,
  0x40,
  0x80
};

static const byte helvR08L1_0x2A_BMP[] = {
  0xA0,
  0x40,
  0xA0
};

static const byte helvR08L1_0x2B_BMP[] = {
  0x20,
  0x20,
  0xF8,
  0x20,
  0x20
};

static const byte helvR08L1_0x2C_BMP[] = {
  0x40,
  0x40,
  0x80
};

static const byte helvR08L1_0x2D_BMP[] = {
  0xE0
};

static const byte helvR08L1_0x2E_BMP[] = {
  0x80
};

static const byte helvR08L1_0x2F_BMP[] = {
  0x20,
  0x20,
  0x40,
  0x40,
  0x40,
  0x40,
  0x80,
  0x80
};

static const byte helvR08L1_0x30_BMP[] = {
  0x70,
  0x88,
  0x88,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0x31_BMP[] = {
  0x40,
  0xC0,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0x32_BMP[] = {
  0x70,
  0x88,
  0x08,
  0x08,
  0x30,
  0x40,
  0x80,
  0xF8
};

static const byte helvR08L1_0x33_BMP[] = {
  0x70,
  0x88,
  0x08,
  0x30,
  0x08,
  0x08,
  0x88,
  0x70
};

static const byte helvR08L1_0x34_BMP[] = {
  0x10,
  0x30,
  0x50,
  0x50,
  0x90,
  0xF8,
  0x10,
  0x10
};

static const byte helvR08L1_0x35_BMP[] = {
  0x78,
  0x40,
  0x40,
  0x70,
  0x08,
  0x08,
  0x88,
  0x70
};

static const byte helvR08L1_0x36_BMP[] = {
  0x70,
  0x88,
  0x80,
  0xF0,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0x37_BMP[] = {
  0xF8,
  0x08,
  0x10,
  0x20,
  0x20,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0x38_BMP[] = {
  0x70,
  0x88,
  0x88,
  0x70,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0x39_BMP[] = {
  0x70,
  0x88,
  0x88,
  0x88,
  0x78,
  0x08,
  0x88,
  0x70
};

static const byte helvR08L1_0x3A_BMP[] = {
  0x80,
  0x00,
  0x00,
  0x00,
  0x00,
  0x80
};

static const byte helvR08L1_0x3B_BMP[] = {
  0x40,
  0x00,
  0x00,
  0x00,
  0x00,
  0x40,
  0x40,
  0x80
};

static const byte helvR08L1_0x3C_BMP[] = {
  0x20,
  0x40,
  0x80,
  0x40,
  0x20
};

static const byte helvR08L1_0x3D_BMP[] = {
  0xF0,
  0x00,
  0xF0
};

static const byte helvR08L1_0x3E_BMP[] = {
  0x80,
  0x40,
  0x20,
  0x40,
  0x80
};

static const byte helvR08L1_0x3F_BMP[] = {
  0x60,
  0x90,
  0x10,
  0x20,
  0x40,
  0x40,
  0x00,
  0x40
};

static const byte helvR08L1_0x40_BMP[] = {
  0x1F, 0x00,
  0x20, 0x80,
  0x4D, 0x40,
  0x92, 0x40,
  0xA2, 0x40,
  0xA4, 0x80,
  0x9B, 0x00,
  0x40, 0x00,
  0x3E, 0x00
};

static const byte helvR08L1_0x41_BMP[] = {
  0x10,
  0x10,
  0x28,
  0x28,
  0x44,
  0x7C,
  0x82,
  0x82
};

static const byte helvR08L1_0x42_BMP[] = {
  0xF0,
  0x88,
  0x88,
  0xF0,
  0x88,
  0x88,
  0x88,
  0xF0
};

static const byte helvR08L1_0x43_BMP[] = {
  0x78,
  0x84,
  0x80,
  0x80,
  0x80,
  0x80,
  0x84,
  0x78
};

static const byte helvR08L1_0x44_BMP[] = {
  0xF0,
  0x88,
  0x84,
  0x84,
  0x84,
  0x84,
  0x88,
  0xF0
};

static const byte helvR08L1_0x45_BMP[] = {
  0xF8,
  0x80,
  0x80,
  0xF8,
  0x80,
  0x80,
  0x80,
  0xF8
};

static const byte helvR08L1_0x46_BMP[] = {
  0xF8,
  0x80,
  0x80,
  0xF0,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0x47_BMP[] = {
  0x78,
  0x84,
  0x80,
  0x80,
  0x8C,
  0x84,
  0x84,
  0x7C
};

static const byte helvR08L1_0x48_BMP[] = {
  0x84,
  0x84,
  0x84,
  0xFC,
  0x84,
  0x84,
  0x84,
  0x84
};

static const byte helvR08L1_0x49_BMP[] = {
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0x4A_BMP[] = {
  0x10,
  0x10,
  0x10,
  0x10,
  0x10,
  0x10,
  0x90,
  0x60
};

static const byte helvR08L1_0x4B_BMP[] = {
  0x88,
  0x90,
  0xA0,
  0xE0,
  0x90,
  0x90,
  0x88,
  0x88
};

static const byte helvR08L1_0x4C_BMP[] = {
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0xF0
};

static const byte helvR08L1_0x4D_BMP[] = {
  0x82,
  0xC6,
  0xC6,
  0xAA,
  0xAA,
  0x92,
  0x92,
  0x92
};

static const byte helvR08L1_0x4E_BMP[] = {
  0xC4,
  0xC4,
  0xA4,
  0xA4,
  0x94,
  0x94,
  0x8C,
  0x8C
};

static const byte helvR08L1_0x4F_BMP[] = {
  0x78,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0x50_BMP[] = {
  0xF0,
  0x88,
  0x88,
  0xF0,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0x51_BMP[] = {
  0x78,
  0x84,
  0x84,
  0x84,
  0x84,
  0x94,
  0x8C,
  0x7C,
  0x02
};

static const byte helvR08L1_0x52_BMP[] = {
  0xF0,
  0x88,
  0x88,
  0xF0,
  0x88,
  0x88,
  0x88,
  0x88
};

static const byte helvR08L1_0x53_BMP[] = {
  0x70,
  0x88,
  0x80,
  0x70,
  0x08,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0x54_BMP[] = {
  0xF8,
  0x20,
  0x20,
  0x20,
  0x20,
  0x20,
  0x20,
  0x20
};

static const byte helvR08L1_0x55_BMP[] = {
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0x56_BMP[] = {
  0x82,
  0x82,
  0x44,
  0x44,
  0x44,
  0x28,
  0x28,
  0x10
};

static const byte helvR08L1_0x57_BMP[] = {
  0x88, 0x80,
  0x88, 0x80,
  0x49, 0x00,
  0x49, 0x00,
  0x55, 0x00,
  0x22, 0x00,
  0x22, 0x00,
  0x22, 0x00
};

static const byte helvR08L1_0x58_BMP[] = {
  0x88,
  0x88,
  0x50,
  0x20,
  0x50,
  0x50,
  0x88,
  0x88
};

static const byte helvR08L1_0x59_BMP[] = {
  0x82,
  0x44,
  0x44,
  0x28,
  0x28,
  0x10,
  0x10,
  0x10
};

static const byte helvR08L1_0x5A_BMP[] = {
  0xF8,
  0x08,
  0x10,
  0x20,
  0x20,
  0x40,
  0x80,
  0xF8
};

static const byte helvR08L1_0x5B_BMP[] = {
  0xC0,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0xC0
};

static const byte helvR08L1_0x5C_BMP[] = {
  0x80,
  0x80,
  0x40,
  0x40,
  0x40,
  0x40,
  0x20,
  0x20
};

static const byte helvR08L1_0x5D_BMP[] = {
  0xC0,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0xC0
};

static const byte helvR08L1_0x5E_BMP[] = {
  0x20,
  0x20,
  0x50,
  0x50,
  0x88
};

static const byte helvR08L1_0x5F_BMP[] = {
  0xFC
};

static const byte helvR08L1_0x60_BMP[] = {
  0x80,
  0x40
};

static const byte helvR08L1_0x61_BMP[] = {
  0xE0,
  0x10,
  0x70,
  0x90,
  0x90,
  0x68
};

static const byte helvR08L1_0x62_BMP[] = {
  0x80,
  0x80,
  0xB0,
  0xC8,
  0x88,
  0x88,
  0xC8,
  0xB0
};

static const byte helvR08L1_0x63_BMP[] = {
  0x60,
  0x90,
  0x80,
  0x80,
  0x90,
  0x60
};

static const byte helvR08L1_0x64_BMP[] = {
  0x08,
  0x08,
  0x68,
  0x98,
  0x88,
  0x88,
  0x98,
  0x68
};

static const byte helvR08L1_0x65_BMP[] = {
  0x60,
  0x90,
  0xF0,
  0x80,
  0x90,
  0x60
};

static const byte helvR08L1_0x66_BMP[] = {
  0x30,
  0x40,
  0xE0,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0x67_BMP[] = {
  0x68,
  0x98,
  0x88,
  0x88,
  0x98,
  0x68,
  0x08,
  0x70
};

static const byte helvR08L1_0x68_BMP[] = {
  0x80,
  0x80,
  0xB0,
  0xC8,
  0x88,
  0x88,
  0x88,
  0x88
};

static const byte helvR08L1_0x69_BMP[] = {
  0x80,
  0x00,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0x6A_BMP[] = {
  0x40,
  0x00,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x80
};

static const byte helvR08L1_0x6B_BMP[] = {
  0x80,
  0x80,
  0x90,
  0xA0,
  0xC0,
  0xA0,
  0x90,
  0x90
};

static const byte helvR08L1_0x6C_BMP[] = {
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0x6D_BMP[] = {
  0xEC,
  0x92,
  0x92,
  0x92,
  0x92,
  0x92
};

static const byte helvR08L1_0x6E_BMP[] = {
  0xB0,
  0xC8,
  0x88,
  0x88,
  0x88,
  0x88
};

static const byte helvR08L1_0x6F_BMP[] = {
  0x70,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0x70_BMP[] = {
  0xB0,
  0xC8,
  0x88,
  0x88,
  0xC8,
  0xB0,
  0x80,
  0x80
};

static const byte helvR08L1_0x71_BMP[] = {
  0x68,
  0x98,
  0x88,
  0x88,
  0x98,
  0x68,
  0x08,
  0x08
};

static const byte helvR08L1_0x72_BMP[] = {
  0xA0,
  0xC0,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0x73_BMP[] = {
  0x60,
  0x90,
  0x60,
  0x10,
  0x90,
  0x60
};

static const byte helvR08L1_0x74_BMP[] = {
  0x40,
  0x40,
  0xE0,
  0x40,
  0x40,
  0x40,
  0x40,
  0x60
};

static const byte helvR08L1_0x75_BMP[] = {
  0x90,
  0x90,
  0x90,
  0x90,
  0x90,
  0x70
};

static const byte helvR08L1_0x76_BMP[] = {
  0x88,
  0x88,
  0x50,
  0x50,
  0x20,
  0x20
};

static const byte helvR08L1_0x77_BMP[] = {
  0x92,
  0x92,
  0x54,
  0x54,
  0x28,
  0x28
};

static const byte helvR08L1_0x78_BMP[] = {
  0x88,
  0x50,
  0x20,
  0x50,
  0x88,
  0x88
};

static const byte helvR08L1_0x79_BMP[] = {
  0x48,
  0x48,
  0x50,
  0x50,
  0x30,
  0x20,
  0x20,
  0xC0
};

static const byte helvR08L1_0x7A_BMP[] = {
  0xF0,
  0x10,
  0x20,
  0x40,
  0x80,
  0xF0
};

static const byte helvR08L1_0x7B_BMP[] = {
  0x20,
  0x40,
  0x40,
  0x40,
  0x80,
  0x40,
  0x40,
  0x40,
  0x40,
  0x20
};

static const byte helvR08L1_0x7C_BMP[] = {
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0x7D_BMP[] = {
  0x80,
  0x40,
  0x40,
  0x40,
  0x20,
  0x40,
  0x40,
  0x40,
  0x40,
  0x80
};

static const byte helvR08L1_0x7E_BMP[] = {
  0x64,
  0x98
};

static const byte helvR08L1_0xA0_BMP[] = {
  0x00
};

static const byte helvR08L1_0xA1_BMP[] = {
  0x80,
  0x00,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0xA2_BMP[] = {
  0x10,
  0x70,
  0xA8,
  0xA0,
  0xA0,
  0xA8,
  0x70,
  0x40
};

static const byte helvR08L1_0xA3_BMP[] = {
  0x30,
  0x48,
  0x40,
  0xE0,
  0x40,
  0x40,
  0x48,
  0xB0
};

static const byte helvR08L1_0xA4_BMP[] = {
  0x90,
  0x60,
  0x90,
  0x90,
  0x60,
  0x90
};

static const byte helvR08L1_0xA5_BMP[] = {
  0x88,
  0x88,
  0x88,
  0x50,
  0xF8,
  0x20,
  0xF8,
  0x20
};

static const byte helvR08L1_0xA6_BMP[] = {
  0x80,
  0x80,
  0x80,
  0x80,
  0x00,
  0x00,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0xA7_BMP[] = {
  0x70,
  0x88,
  0xC0,
  0x70,
  0x98,
  0xC8,
  0x70,
  0x18,
  0x88,
  0x70
};

static const byte helvR08L1_0xA8_BMP[] = {
  0xA0
};

static const byte helvR08L1_0xA9_BMP[] = {
  0x38,
  0x44,
  0x9A,
  0xA2,
  0x9A,
  0x44,
  0x38
};

static const byte helvR08L1_0xAA_BMP[] = {
  0xE0,
  0x20,
  0xA0,
  0x00,
  0xE0
};

static const byte helvR08L1_0xAB_BMP[] = {
  0x28,
  0x50,
  0xA0,
  0x50,
  0x28
};

static const byte helvR08L1_0xAC_BMP[] = {
  0xF8,
  0x08,
  0x08
};

static const byte helvR08L1_0xAD_BMP[] = {
  0xE0
};

static const byte helvR08L1_0xAE_BMP[] = {
  0x38,
  0x44,
  0xBA,
  0xB2,
  0xAA,
  0x44,
  0x38
};

static const byte helvR08L1_0xAF_BMP[] = {
  0xE0
};

static const byte helvR08L1_0xB0_BMP[] = {
  0x60,
  0x90,
  0x90,
  0x60
};

static const byte helvR08L1_0xB1_BMP[] = {
  0x20,
  0x20,
  0xF8,
  0x20,
  0x20,
  0x00,
  0xF8
};

static const byte helvR08L1_0xB2_BMP[] = {
  0x60,
  0xA0,
  0x40,
  0xE0
};

static const byte helvR08L1_0xB3_BMP[] = {
  0xE0,
  0x40,
  0x20,
  0xC0
};

static const byte helvR08L1_0xB4_BMP[] = {
  0x40,
  0x80
};

static const byte helvR08L1_0xB5_BMP[] = {
  0x90,
  0x90,
  0x90,
  0x90,
  0x90,
  0xF0,
  0x80,
  0x80
};

static const byte helvR08L1_0xB6_BMP[] = {
  0x7C,
  0xE8,
  0xE8,
  0xE8,
  0x68,
  0x28,
  0x28,
  0x28,
  0x28,
  0x28
};

static const byte helvR08L1_0xB7_BMP[] = {
  0xC0
};

static const byte helvR08L1_0xB8_BMP[] = {
  0x40,
  0xC0
};

static const byte helvR08L1_0xB9_BMP[] = {
  0x40,
  0xC0,
  0x40,
  0x40
};

static const byte helvR08L1_0xBA_BMP[] = {
  0xE0,
  0xA0,
  0xE0,
  0x00,
  0xE0
};

static const byte helvR08L1_0xBB_BMP[] = {
  0xA0,
  0x50,
  0x28,
  0x50,
  0xA0
};

static const byte helvR08L1_0xBC_BMP[] = {
  0x44, 0x00,
  0xC4, 0x00,
  0x48, 0x00,
  0x48, 0x00,
  0x11, 0x00,
  0x13, 0x00,
  0x27, 0x80,
  0x21, 0x00
};

static const byte helvR08L1_0xBD_BMP[] = {
  0x44,
  0xC4,
  0x48,
  0x48,
  0x13,
  0x15,
  0x22,
  0x27
};

static const byte helvR08L1_0xBE_BMP[] = {
  0xE0, 0x00,
  0x44, 0x00,
  0x24, 0x00,
  0xC8, 0x00,
  0x09, 0x00,
  0x13, 0x00,
  0x17, 0x80,
  0x21, 0x00
};

static const byte helvR08L1_0xBF_BMP[] = {
  0x20,
  0x00,
  0x20,
  0x20,
  0x40,
  0x80,
  0x90,
  0x60
};

static const byte helvR08L1_0xC0_BMP[] = {
  0x20,
  0x10,
  0x00,
  0x10,
  0x10,
  0x28,
  0x28,
  0x44,
  0x7C,
  0x82,
  0x82
};

static const byte helvR08L1_0xC1_BMP[] = {
  0x08,
  0x10,
  0x00,
  0x10,
  0x10,
  0x28,
  0x28,
  0x44,
  0x7C,
  0x82,
  0x82
};

static const byte helvR08L1_0xC2_BMP[] = {
  0x10,
  0x28,
  0x00,
  0x10,
  0x10,
  0x28,
  0x28,
  0x44,
  0x7C,
  0x82,
  0x82
};

static const byte helvR08L1_0xC3_BMP[] = {
  0x14,
  0x28,
  0x00,
  0x10,
  0x10,
  0x28,
  0x28,
  0x44,
  0x7C,
  0x82,
  0x82
};

static const byte helvR08L1_0xC4_BMP[] = {
  0x28,
  0x00,
  0x10,
  0x10,
  0x28,
  0x28,
  0x44,
  0x7C,
  0x82,
  0x82
};

static const byte helvR08L1_0xC5_BMP[] = {
  0x10,
  0x28,
  0x10,
  0x10,
  0x10,
  0x28,
  0x28,
  0x44,
  0x7C,
  0x82,
  0x82
};

static const byte helvR08L1_0xC6_BMP[] = {
  0x1F, 0x80,
  0x18, 0x00,
  0x28, 0x00,
  0x2F, 0x80,
  0x48, 0x00,
  0x78, 0x00,
  0x88, 0x00,
  0x8F, 0x80
};

static const byte helvR08L1_0xC7_BMP[] = {
  0x78,
  0x84,
  0x80,
  0x80,
  0x80,
  0x80,
  0x84,
  0x78,
  0x10,
  0x30
};

static const byte helvR08L1_0xC8_BMP[] = {
  0x40,
  0x20,
  0x00,
  0xF8,
  0x80,
  0x80,
  0xF8,
  0x80,
  0x80,
  0x80,
  0xF8
};

static const byte helvR08L1_0xC9_BMP[] = {
  0x10,
  0x20,
  0x00,
  0xF8,
  0x80,
  0x80,
  0xF8,
  0x80,
  0x80,
  0x80,
  0xF8
};

static const byte helvR08L1_0xCA_BMP[] = {
  0x20,
  0x50,
  0x00,
  0xF8,
  0x80,
  0x80,
  0xF8,
  0x80,
  0x80,
  0x80,
  0xF8
};

static const byte helvR08L1_0xCB_BMP[] = {
  0x50,
  0x00,
  0xF8,
  0x80,
  0x80,
  0xF8,
  0x80,
  0x80,
  0x80,
  0xF8
};

static const byte helvR08L1_0xCC_BMP[] = {
  0x80,
  0x40,
  0x00,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0xCD_BMP[] = {
  0x40,
  0x80,
  0x00,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0xCE_BMP[] = {
  0x40,
  0xA0,
  0x00,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0xCF_BMP[] = {
  0xA0,
  0x00,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0xD0_BMP[] = {
  0x78,
  0x44,
  0x42,
  0xF2,
  0x42,
  0x42,
  0x44,
  0x78
};

static const byte helvR08L1_0xD1_BMP[] = {
  0x28,
  0x50,
  0x00,
  0xC4,
  0xC4,
  0xA4,
  0xA4,
  0x94,
  0x94,
  0x8C,
  0x8C
};

static const byte helvR08L1_0xD2_BMP[] = {
  0x20,
  0x10,
  0x00,
  0x78,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xD3_BMP[] = {
  0x08,
  0x10,
  0x00,
  0x78,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xD4_BMP[] = {
  0x20,
  0x50,
  0x00,
  0x78,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xD5_BMP[] = {
  0x28,
  0x50,
  0x00,
  0x78,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xD6_BMP[] = {
  0x48,
  0x00,
  0x78,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xD7_BMP[] = {
  0x88,
  0x50,
  0x20,
  0x50,
  0x88
};

static const byte helvR08L1_0xD8_BMP[] = {
  0x04,
  0x78,
  0x8C,
  0x94,
  0x94,
  0xA4,
  0xA4,
  0xC4,
  0x78,
  0x80
};

static const byte helvR08L1_0xD9_BMP[] = {
  0x20,
  0x10,
  0x00,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xDA_BMP[] = {
  0x08,
  0x10,
  0x00,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xDB_BMP[] = {
  0x20,
  0x50,
  0x00,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xDC_BMP[] = {
  0x48,
  0x00,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x84,
  0x78
};

static const byte helvR08L1_0xDD_BMP[] = {
  0x08,
  0x10,
  0x00,
  0x82,
  0x44,
  0x44,
  0x28,
  0x28,
  0x10,
  0x10,
  0x10
};

static const byte helvR08L1_0xDE_BMP[] = {
  0x80,
  0x80,
  0xF0,
  0x88,
  0x88,
  0xF0,
  0x80,
  0x80
};

static const byte helvR08L1_0xDF_BMP[] = {
  0x60,
  0x90,
  0x90,
  0xA0,
  0x90,
  0x90,
  0x90,
  0xA0
};

static const byte helvR08L1_0xE0_BMP[] = {
  0x40,
  0x20,
  0x00,
  0xE0,
  0x10,
  0x70,
  0x90,
  0x90,
  0x68
};

static const byte helvR08L1_0xE1_BMP[] = {
  0x20,
  0x40,
  0x00,
  0xE0,
  0x10,
  0x70,
  0x90,
  0x90,
  0x68
};

static const byte helvR08L1_0xE2_BMP[] = {
  0x20,
  0x50,
  0x00,
  0xE0,
  0x10,
  0x70,
  0x90,
  0x90,
  0x68
};

static const byte helvR08L1_0xE3_BMP[] = {
  0x50,
  0xA0,
  0x00,
  0xE0,
  0x10,
  0x70,
  0x90,
  0x90,
  0x68
};

static const byte helvR08L1_0xE4_BMP[] = {
  0x50,
  0x00,
  0xE0,
  0x10,
  0x70,
  0x90,
  0x90,
  0x68
};

static const byte helvR08L1_0xE5_BMP[] = {
  0x20,
  0x50,
  0x20,
  0xE0,
  0x10,
  0x70,
  0x90,
  0x90,
  0x68
};

static const byte helvR08L1_0xE6_BMP[] = {
  0xEC,
  0x12,
  0x7E,
  0x90,
  0x92,
  0x6C
};

static const byte helvR08L1_0xE7_BMP[] = {
  0x60,
  0x90,
  0x80,
  0x80,
  0x90,
  0x60,
  0x20,
  0x60
};

static const byte helvR08L1_0xE8_BMP[] = {
  0x40,
  0x20,
  0x00,
  0x60,
  0x90,
  0xF0,
  0x80,
  0x90,
  0x60
};

static const byte helvR08L1_0xE9_BMP[] = {
  0x20,
  0x40,
  0x00,
  0x60,
  0x90,
  0xF0,
  0x80,
  0x90,
  0x60
};

static const byte helvR08L1_0xEA_BMP[] = {
  0x40,
  0xA0,
  0x00,
  0x60,
  0x90,
  0xF0,
  0x80,
  0x90,
  0x60
};

static const byte helvR08L1_0xEB_BMP[] = {
  0xA0,
  0x00,
  0x60,
  0x90,
  0xF0,
  0x80,
  0x90,
  0x60
};

static const byte helvR08L1_0xEC_BMP[] = {
  0x80,
  0x40,
  0x00,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0xED_BMP[] = {
  0x40,
  0x80,
  0x00,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80,
  0x80
};

static const byte helvR08L1_0xEE_BMP[] = {
  0x40,
  0xA0,
  0x00,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0xEF_BMP[] = {
  0xA0,
  0x00,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40,
  0x40
};

static const byte helvR08L1_0xF0_BMP[] = {
  0x40,
  0x78,
  0x90,
  0x78,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0xF1_BMP[] = {
  0x50,
  0xA0,
  0x00,
  0xE0,
  0x90,
  0x90,
  0x90,
  0x90,
  0x90
};

static const byte helvR08L1_0xF2_BMP[] = {
  0x40,
  0x20,
  0x00,
  0x70,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0xF3_BMP[] = {
  0x10,
  0x20,
  0x00,
  0x70,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0xF4_BMP[] = {
  0x20,
  0x50,
  0x00,
  0x70,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0xF5_BMP[] = {
  0x28,
  0x50,
  0x00,
  0x70,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0xF6_BMP[] = {
  0x50,
  0x00,
  0x70,
  0x88,
  0x88,
  0x88,
  0x88,
  0x70
};

static const byte helvR08L1_0xF7_BMP[] = {
  0x20,
  0x00,
  0xF8,
  0x00,
  0x20
};

static const byte helvR08L1_0xF8_BMP[] = {
  0x3A,
  0x4C,
  0x54,
  0x64,
  0x44,
  0xB8
};

static const byte helvR08L1_0xF9_BMP[] = {
  0x40,
  0x20,
  0x00,
  0x90,
  0x90,
  0x90,
  0x90,
  0x90,
  0x70
};

static const byte helvR08L1_0xFA_BMP[] = {
  0x10,
  0x20,
  0x00,
  0x90,
  0x90,
  0x90,
  0x90,
  0x90,
  0x70
};

static const byte helvR08L1_0xFB_BMP[] = {
  0x40,
  0xA0,
  0x00,
  0x90,
  0x90,
  0x90,
  0x90,
  0x90,
  0x70
};

static const byte helvR08L1_0xFC_BMP[] = {
  0xA0,
  0x00,
  0x90,
  0x90,
  0x90,
  0x90,
  0x90,
  0x70
};

static const byte helvR08L1_0xFD_BMP[] = {
  0x08,
  0x10,
  0x00,
  0x48,
  0x48,
  0x50,
  0x50,
  0x30,
  0x20,
  0x20,
  0xC0
};

static const byte helvR08L1_0xFE_BMP[] = {
  0x80,
  0x80,
  0xB0,
  0xC8,
  0x88,
  0x88,
  0xC8,
  0xB0,
  0x80,
  0x80
};

static const byte helvR08L1_0xFF_BMP[] = {
  0x50,
  0x00,
  0x48,
  0x48,
  0x50,
  0x50,
  0x30,
  0x20,
  0x20,
  0xC0
};

static const GFONT_CharInfo FontBMP[] = {
  {8, 5, 7, 1, 0, helvR08L1_0x00_BMP},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {3, 1, 1, 0, 0, helvR08L1_0x20_BMP},
  {3, 1, 8, 1, 0, helvR08L1_0x21_BMP},
  {4, 3, 2, 1, 6, helvR08L1_0x22_BMP},
  {6, 6, 7, 0, 0, helvR08L1_0x23_BMP},
  {6, 5, 10, 0, -1, helvR08L1_0x24_BMP},
  {9, 8, 8, 0, 0, helvR08L1_0x25_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x26_BMP},
  {2, 1, 2, 0, 6, helvR08L1_0x27_BMP},
  {4, 3, 10, 0, -2, helvR08L1_0x28_BMP},
  {4, 3, 10, 1, -2, helvR08L1_0x29_BMP},
  {4, 3, 3, 0, 5, helvR08L1_0x2A_BMP},
  {6, 5, 5, 0, 1, helvR08L1_0x2B_BMP},
  {3, 2, 3, 0, -2, helvR08L1_0x2C_BMP},
  {4, 3, 1, 0, 3, helvR08L1_0x2D_BMP},
  {3, 1, 1, 1, 0, helvR08L1_0x2E_BMP},
  {3, 3, 8, 0, 0, helvR08L1_0x2F_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x30_BMP},
  {6, 2, 8, 1, 0, helvR08L1_0x31_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x32_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x33_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x34_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x35_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x36_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x37_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x38_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x39_BMP},
  {3, 1, 6, 1, 0, helvR08L1_0x3A_BMP},
  {3, 2, 8, 0, -2, helvR08L1_0x3B_BMP},
  {6, 3, 5, 1, 1, helvR08L1_0x3C_BMP},
  {5, 4, 3, 0, 2, helvR08L1_0x3D_BMP},
  {6, 3, 5, 1, 1, helvR08L1_0x3E_BMP},
  {6, 4, 8, 1, 0, helvR08L1_0x3F_BMP},
  {11, 10, 9, 0, -1, helvR08L1_0x40_BMP},
  {7, 7, 8, 0, 0, helvR08L1_0x41_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x42_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x43_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x44_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x45_BMP},
  {6, 5, 8, 1, 0, helvR08L1_0x46_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x47_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x48_BMP},
  {3, 1, 8, 1, 0, helvR08L1_0x49_BMP},
  {5, 4, 8, 0, 0, helvR08L1_0x4A_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x4B_BMP},
  {6, 4, 8, 1, 0, helvR08L1_0x4C_BMP},
  {9, 7, 8, 1, 0, helvR08L1_0x4D_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x4E_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x4F_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x50_BMP},
  {8, 7, 9, 1, -1, helvR08L1_0x51_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x52_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x53_BMP},
  {5, 5, 8, 0, 0, helvR08L1_0x54_BMP},
  {8, 6, 8, 1, 0, helvR08L1_0x55_BMP},
  {7, 7, 8, 0, 0, helvR08L1_0x56_BMP},
  {9, 9, 8, 0, 0, helvR08L1_0x57_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x58_BMP},
  {7, 7, 8, 0, 0, helvR08L1_0x59_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0x5A_BMP},
  {3, 2, 10, 1, -2, helvR08L1_0x5B_BMP},
  {3, 3, 8, 0, 0, helvR08L1_0x5C_BMP},
  {3, 2, 10, 0, -2, helvR08L1_0x5D_BMP},
  {6, 5, 5, 0, 3, helvR08L1_0x5E_BMP},
  {6, 6, 1, 0, -2, helvR08L1_0x5F_BMP},
  {3, 2, 2, 0, 7, helvR08L1_0x60_BMP},
  {5, 5, 6, 0, 0, helvR08L1_0x61_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x62_BMP},
  {5, 4, 6, 0, 0, helvR08L1_0x63_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x64_BMP},
  {5, 4, 6, 0, 0, helvR08L1_0x65_BMP},
  {4, 4, 8, 0, 0, helvR08L1_0x66_BMP},
  {6, 5, 8, 0, -2, helvR08L1_0x67_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0x68_BMP},
  {2, 1, 8, 0, 0, helvR08L1_0x69_BMP},
  {2, 2, 10, -1, -2, helvR08L1_0x6A_BMP},
  {5, 4, 8, 0, 0, helvR08L1_0x6B_BMP},
  {2, 1, 8, 0, 0, helvR08L1_0x6C_BMP},
  {8, 7, 6, 0, 0, helvR08L1_0x6D_BMP},
  {6, 5, 6, 0, 0, helvR08L1_0x6E_BMP},
  {6, 5, 6, 0, 0, helvR08L1_0x6F_BMP},
  {6, 5, 8, 0, -2, helvR08L1_0x70_BMP},
  {6, 5, 8, 0, -2, helvR08L1_0x71_BMP},
  {4, 3, 6, 0, 0, helvR08L1_0x72_BMP},
  {5, 4, 6, 0, 0, helvR08L1_0x73_BMP},
  {4, 3, 8, 0, 0, helvR08L1_0x74_BMP},
  {5, 4, 6, 0, 0, helvR08L1_0x75_BMP},
  {6, 5, 6, 0, 0, helvR08L1_0x76_BMP},
  {8, 7, 6, 0, 0, helvR08L1_0x77_BMP},
  {6, 5, 6, 0, 0, helvR08L1_0x78_BMP},
  {5, 5, 8, -1, -2, helvR08L1_0x79_BMP},
  {5, 4, 6, 0, 0, helvR08L1_0x7A_BMP},
  {3, 3, 10, 0, -2, helvR08L1_0x7B_BMP},
  {3, 1, 10, 1, -2, helvR08L1_0x7C_BMP},
  {3, 3, 10, 0, -2, helvR08L1_0x7D_BMP},
  {7, 6, 2, 0, 3, helvR08L1_0x7E_BMP},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {0, 0, 0, 0, 0, NULL},
  {3, 1, 1, 0, 0, helvR08L1_0xA0_BMP},
  {3, 1, 8, 1, -2, helvR08L1_0xA1_BMP},
  {6, 5, 8, 1, -1, helvR08L1_0xA2_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0xA3_BMP},
  {5, 4, 6, 0, 1, helvR08L1_0xA4_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0xA5_BMP},
  {3, 1, 10, 1, -2, helvR08L1_0xA6_BMP},
  {6, 5, 10, 0, -2, helvR08L1_0xA7_BMP},
  {3, 3, 1, 0, 7, helvR08L1_0xA8_BMP},
  {9, 7, 7, 1, 0, helvR08L1_0xA9_BMP},
  {4, 3, 5, 0, 3, helvR08L1_0xAA_BMP},
  {6, 5, 5, 0, 0, helvR08L1_0xAB_BMP},
  {7, 5, 3, 1, 2, helvR08L1_0xAC_BMP},
  {4, 3, 1, 0, 3, helvR08L1_0xAD_BMP},
  {9, 7, 7, 1, 0, helvR08L1_0xAE_BMP},
  {3, 3, 1, 0, 7, helvR08L1_0xAF_BMP},
  {4, 4, 4, 0, 4, helvR08L1_0xB0_BMP},
  {6, 5, 7, 0, 0, helvR08L1_0xB1_BMP},
  {3, 3, 4, 0, 4, helvR08L1_0xB2_BMP},
  {3, 3, 4, 0, 4, helvR08L1_0xB3_BMP},
  {3, 2, 2, 0, 7, helvR08L1_0xB4_BMP},
  {5, 4, 8, 0, -2, helvR08L1_0xB5_BMP},
  {6, 6, 10, 0, -2, helvR08L1_0xB6_BMP},
  {3, 2, 1, 0, 3, helvR08L1_0xB7_BMP},
  {3, 2, 2, 0, -2, helvR08L1_0xB8_BMP},
  {3, 2, 4, 0, 4, helvR08L1_0xB9_BMP},
  {4, 3, 5, 0, 3, helvR08L1_0xBA_BMP},
  {6, 5, 5, 0, 0, helvR08L1_0xBB_BMP},
  {9, 9, 8, 0, 0, helvR08L1_0xBC_BMP},
  {9, 8, 8, 0, 0, helvR08L1_0xBD_BMP},
  {9, 9, 8, 0, 0, helvR08L1_0xBE_BMP},
  {6, 4, 8, 1, -2, helvR08L1_0xBF_BMP},
  {7, 7, 11, 0, 0, helvR08L1_0xC0_BMP},
  {7, 7, 11, 0, 0, helvR08L1_0xC1_BMP},
  {7, 7, 11, 0, 0, helvR08L1_0xC2_BMP},
  {7, 7, 11, 0, 0, helvR08L1_0xC3_BMP},
  {7, 7, 10, 0, 0, helvR08L1_0xC4_BMP},
  {7, 7, 11, 0, 0, helvR08L1_0xC5_BMP},
  {10, 9, 8, 0, 0, helvR08L1_0xC6_BMP},
  {8, 6, 10, 1, -2, helvR08L1_0xC7_BMP},
  {7, 5, 11, 1, 0, helvR08L1_0xC8_BMP},
  {7, 5, 11, 1, 0, helvR08L1_0xC9_BMP},
  {7, 5, 11, 1, 0, helvR08L1_0xCA_BMP},
  {7, 5, 10, 1, 0, helvR08L1_0xCB_BMP},
  {3, 2, 11, 0, 0, helvR08L1_0xCC_BMP},
  {3, 2, 11, 1, 0, helvR08L1_0xCD_BMP},
  {3, 3, 11, 0, 0, helvR08L1_0xCE_BMP},
  {3, 3, 10, 0, 0, helvR08L1_0xCF_BMP},
  {8, 7, 8, 0, 0, helvR08L1_0xD0_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xD1_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xD2_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xD3_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xD4_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xD5_BMP},
  {8, 6, 10, 1, 0, helvR08L1_0xD6_BMP},
  {6, 5, 5, 0, 1, helvR08L1_0xD7_BMP},
  {8, 6, 10, 1, -1, helvR08L1_0xD8_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xD9_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xDA_BMP},
  {8, 6, 11, 1, 0, helvR08L1_0xDB_BMP},
  {8, 6, 10, 1, 0, helvR08L1_0xDC_BMP},
  {7, 7, 11, 0, 0, helvR08L1_0xDD_BMP},
  {7, 5, 8, 1, 0, helvR08L1_0xDE_BMP},
  {5, 4, 8, 0, 0, helvR08L1_0xDF_BMP},
  {5, 5, 9, 0, 0, helvR08L1_0xE0_BMP},
  {5, 5, 9, 0, 0, helvR08L1_0xE1_BMP},
  {5, 5, 9, 0, 0, helvR08L1_0xE2_BMP},
  {5, 5, 9, 0, 0, helvR08L1_0xE3_BMP},
  {5, 5, 8, 0, 0, helvR08L1_0xE4_BMP},
  {5, 5, 9, 0, 0, helvR08L1_0xE5_BMP},
  {8, 7, 6, 0, 0, helvR08L1_0xE6_BMP},
  {5, 4, 8, 0, -2, helvR08L1_0xE7_BMP},
  {5, 4, 9, 0, 0, helvR08L1_0xE8_BMP},
  {5, 4, 9, 0, 0, helvR08L1_0xE9_BMP},
  {5, 4, 9, 0, 0, helvR08L1_0xEA_BMP},
  {5, 4, 8, 0, 0, helvR08L1_0xEB_BMP},
  {2, 2, 9, -1, 0, helvR08L1_0xEC_BMP},
  {2, 2, 9, 0, 0, helvR08L1_0xED_BMP},
  {2, 3, 9, -1, 0, helvR08L1_0xEE_BMP},
  {2, 3, 8, -1, 0, helvR08L1_0xEF_BMP},
  {6, 5, 9, 0, 0, helvR08L1_0xF0_BMP},
  {5, 4, 9, 0, 0, helvR08L1_0xF1_BMP},
  {6, 5, 9, 0, 0, helvR08L1_0xF2_BMP},
  {6, 5, 9, 0, 0, helvR08L1_0xF3_BMP},
  {6, 5, 9, 0, 0, helvR08L1_0xF4_BMP},
  {6, 5, 9, 0, 0, helvR08L1_0xF5_BMP},
  {6, 5, 8, 0, 0, helvR08L1_0xF6_BMP},
  {6, 5, 5, 0, 1, helvR08L1_0xF7_BMP},
  {6, 7, 6, -1, 0, helvR08L1_0xF8_BMP},
  {5, 4, 9, 0, 0, helvR08L1_0xF9_BMP},
  {5, 4, 9, 0, 0, helvR08L1_0xFA_BMP},
  {5, 4, 9, 0, 0, helvR08L1_0xFB_BMP},
  {5, 4, 8, 0, 0, helvR08L1_0xFC_BMP},
  {5, 5, 11, -1, -2, helvR08L1_0xFD_BMP},
  {6, 5, 10, 0, -2, helvR08L1_0xFE_BMP},
  {5, 5, 10, -1, -2, helvR08L1_0xFF_BMP}
};


/*
** ===================================================================
**     Method      :  GFONT1_GetFontChar (component GFont)
**
**     Description :
**         Returns for a given character the corresponding font bitmap.
**     Parameters  :
**         NAME            - DESCRIPTION
**         ch              - The character for that a bitmap is required.
**     Returns     :
**         ---             - Character font bitmap
** ===================================================================
*/
PGFONT_CharInfo GFONT1_GetFontChar(byte ch)
{
  return (PGFONT_CharInfo)&FontBMP[ch];
}

/*
** ===================================================================
**     Method      :  GFONT1_GetBoxHeight (component GFont)
**
**     Description :
**         Function to get the height of the bounding box.
**     Parameters  : None
**     Returns     :
**         ---             - Height of bounding box
** ===================================================================
*/
#if 0
byte GFONT1_GetBoxHeight(void)
{
  /* implemented as macro */
}
#endif

/*
** ===================================================================
**     Method      :  GFONT1_GetFont (component GFont)
**
**     Description :
**         Returns callbacks for fonts to be used by the font driver.
**     Parameters  : None
**     Returns     :
**         ---             - Font callbacks.
** ===================================================================
*/
PGFONT_Callbacks GFONT1_GetFont(void)
{
  static const GFONT_Callbacks callbacks = {
    GFONT1_GetFontChar,
    GFONT1_GetBoxHeight(),
    GFONT1_GetUnderlineBoxHeight(),
    GFONT1_GetLineSpaceHeight()
  };
  return (PGFONT_Callbacks)&callbacks;
}

/*
** ===================================================================
**     Method      :  GFONT1_GetUnderlineBoxHeight (component GFont)
**
**     Description :
**         Returns the size of the underline box height
**     Parameters  : None
**     Returns     :
**         ---             - Error code
** ===================================================================
*/
#if 0
byte GFONT1_GetUnderlineBoxHeight(void)
{
  /* function is implemented as a macro */
}
#endif

/*
** ===================================================================
**     Method      :  GFONT1_GetLineSpaceHeight (component GFont)
**
**     Description :
**         Returns the size of the line space height
**     Parameters  : None
**     Returns     :
**         ---             - Error code
** ===================================================================
*/
#if 0
byte GFONT1_GetLineSpaceHeight(void)
{
  /* function implemented as a macro */
}
#endif

/* END GFONT1. */

/*
** ###################################################################
**
**     This file was created by Processor Expert 5.3 [05.01]
**     for the Freescale HCS08 series of microcontrollers.
**
** ###################################################################
*/
